home *** CD-ROM | disk | FTP | other *** search
/ PC Plus SuperCD (UK) 1998 August / PC Plus SuperCD 50a Issue 142 (CD142a) (August 1998).iso / trial / demon / TURNPIKE.1 / CLASSES.ZIP / JAVA / IO / StreamTokenizer.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-04-14  |  3.9 KB  |  382 lines
  1. package java.io;
  2.  
  3. public class StreamTokenizer {
  4.    private InputStream input;
  5.    private char[] buf;
  6.    private int peekc = 32;
  7.    private boolean pushedBack;
  8.    private boolean forceLower;
  9.    private int LINENO = 1;
  10.    private boolean eolIsSignificantP = false;
  11.    private boolean slashSlashCommentsP = false;
  12.    private boolean slashStarCommentsP = false;
  13.    private byte[] ctype = new byte[256];
  14.    private static final byte CT_WHITESPACE = 1;
  15.    private static final byte CT_DIGIT = 2;
  16.    private static final byte CT_ALPHA = 4;
  17.    private static final byte CT_QUOTE = 8;
  18.    private static final byte CT_COMMENT = 16;
  19.    public int ttype;
  20.    public static final int TT_EOF = -1;
  21.    public static final int TT_EOL = 10;
  22.    public static final int TT_NUMBER = -2;
  23.    public static final int TT_WORD = -3;
  24.    public String sval;
  25.    public double nval;
  26.  
  27.    public StreamTokenizer(InputStream var1) {
  28.       this.input = var1;
  29.       this.buf = new char[20];
  30.       this.wordChars(97, 122);
  31.       this.wordChars(65, 90);
  32.       this.wordChars(160, 255);
  33.       this.whitespaceChars(0, 32);
  34.       this.commentChar(47);
  35.       this.quoteChar(34);
  36.       this.quoteChar(39);
  37.       this.parseNumbers();
  38.    }
  39.  
  40.    public void resetSyntax() {
  41.       int var1 = this.ctype.length;
  42.  
  43.       while(true) {
  44.          --var1;
  45.          if (var1 < 0) {
  46.             return;
  47.          }
  48.  
  49.          this.ctype[var1] = 0;
  50.       }
  51.    }
  52.  
  53.    public void wordChars(int var1, int var2) {
  54.       if (var1 < 0) {
  55.          var1 = 0;
  56.       }
  57.  
  58.       if (var2 > this.ctype.length) {
  59.          var2 = this.ctype.length;
  60.       }
  61.  
  62.       while(var1 <= var2) {
  63.          byte[] var10000 = this.ctype;
  64.          int var10001 = var1++;
  65.          var10000[var10001] = (byte)(var10000[var10001] | 4);
  66.       }
  67.  
  68.    }
  69.  
  70.    public void whitespaceChars(int var1, int var2) {
  71.       if (var1 < 0) {
  72.          var1 = 0;
  73.       }
  74.  
  75.       if (var2 > this.ctype.length) {
  76.          var2 = this.ctype.length;
  77.       }
  78.  
  79.       while(var1 <= var2) {
  80.          this.ctype[var1++] = 1;
  81.       }
  82.  
  83.    }
  84.  
  85.    public void ordinaryChars(int var1, int var2) {
  86.       if (var1 < 0) {
  87.          var1 = 0;
  88.       }
  89.  
  90.       if (var2 > this.ctype.length) {
  91.          var2 = this.ctype.length;
  92.       }
  93.  
  94.       while(var1 <= var2) {
  95.          this.ctype[var1++] = 0;
  96.       }
  97.  
  98.    }
  99.  
  100.    public void ordinaryChar(int var1) {
  101.       this.ctype[var1] = 0;
  102.    }
  103.  
  104.    public void commentChar(int var1) {
  105.       this.ctype[var1] = 16;
  106.    }
  107.  
  108.    public void quoteChar(int var1) {
  109.       this.ctype[var1] = 8;
  110.    }
  111.  
  112.    public void parseNumbers() {
  113.       for(int var1 = 48; var1 <= 57; ++var1) {
  114.          byte[] var10000 = this.ctype;
  115.          var10000[var1] = (byte)(var10000[var1] | 2);
  116.       }
  117.  
  118.       byte[] var2 = this.ctype;
  119.       var2[46] = (byte)(var2[46] | 2);
  120.       var2 = this.ctype;
  121.       var2[45] = (byte)(var2[45] | 2);
  122.    }
  123.  
  124.    public void eolIsSignificant(boolean var1) {
  125.       this.eolIsSignificantP = var1;
  126.    }
  127.  
  128.    public void slashStarComments(boolean var1) {
  129.       this.slashStarCommentsP = var1;
  130.    }
  131.  
  132.    public void slashSlashComments(boolean var1) {
  133.       this.slashSlashCommentsP = var1;
  134.    }
  135.  
  136.    public void lowerCaseMode(boolean var1) {
  137.       this.forceLower = var1;
  138.    }
  139.  
  140.    public int nextToken() throws IOException {
  141.       if (this.pushedBack) {
  142.          this.pushedBack = false;
  143.          return this.ttype;
  144.       } else {
  145.          InputStream var1 = this.input;
  146.          byte[] var2 = this.ctype;
  147.          int var3 = this.peekc;
  148.          this.sval = null;
  149.          if (var3 < 0) {
  150.             return this.ttype = -1;
  151.          } else {
  152.             byte var4;
  153.             for(var4 = var3 < 256 ? var2[var3] : 4; (var4 & 1) != 0; var4 = var3 < 256 ? var2[var3] : 4) {
  154.                if (var3 == 13) {
  155.                   ++this.LINENO;
  156.                   var3 = var1.read();
  157.                   if (var3 == 10) {
  158.                      var3 = var1.read();
  159.                   }
  160.  
  161.                   if (this.eolIsSignificantP) {
  162.                      this.peekc = var3;
  163.                      return this.ttype = 10;
  164.                   }
  165.                } else {
  166.                   if (var3 == 10) {
  167.                      ++this.LINENO;
  168.                      if (this.eolIsSignificantP) {
  169.                         this.peekc = 32;
  170.                         return this.ttype = 10;
  171.                      }
  172.                   }
  173.  
  174.                   var3 = var1.read();
  175.                }
  176.  
  177.                if (var3 < 0) {
  178.                   return this.ttype = -1;
  179.                }
  180.             }
  181.  
  182.             if ((var4 & 2) != 0) {
  183.                boolean var20 = false;
  184.                if (var3 == 45) {
  185.                   var3 = var1.read();
  186.                   if (var3 != 46 && (var3 < 48 || var3 > 57)) {
  187.                      this.peekc = var3;
  188.                      return this.ttype = 45;
  189.                   }
  190.  
  191.                   var20 = true;
  192.                }
  193.  
  194.                double var24 = (double)0.0F;
  195.                int var8 = 0;
  196.                byte var9 = 0;
  197.  
  198.                while(true) {
  199.                   if (var3 == 46 && var9 == 0) {
  200.                      var9 = 1;
  201.                   } else {
  202.                      if (var3 < 48 || var3 > 57) {
  203.                         this.peekc = var3;
  204.                         if (var8 != 0) {
  205.                            double var10 = (double)10.0F;
  206.                            --var8;
  207.  
  208.                            while(var8 > 0) {
  209.                               var10 *= (double)10.0F;
  210.                               --var8;
  211.                            }
  212.  
  213.                            var24 /= var10;
  214.                         }
  215.  
  216.                         this.nval = var20 ? -var24 : var24;
  217.                         return this.ttype = -2;
  218.                      }
  219.  
  220.                      var24 = var24 * (double)10.0F + (double)(var3 - 48);
  221.                      var8 += var9;
  222.                   }
  223.  
  224.                   var3 = var1.read();
  225.                }
  226.             } else if ((var4 & 4) != 0) {
  227.                int var19 = 0;
  228.  
  229.                do {
  230.                   if (var19 >= this.buf.length) {
  231.                      char[] var23 = new char[this.buf.length * 2];
  232.                      System.arraycopy(this.buf, 0, var23, 0, this.buf.length);
  233.                      this.buf = var23;
  234.                   }
  235.  
  236.                   this.buf[var19++] = (char)var3;
  237.                   var3 = var1.read();
  238.                   var4 = var3 < 0 ? 1 : (var3 < 256 ? var2[var3] : 4);
  239.                } while((var4 & 6) != 0);
  240.  
  241.                this.peekc = var3;
  242.                this.sval = String.copyValueOf(this.buf, 0, var19);
  243.                if (this.forceLower) {
  244.                   this.sval = this.sval.toLowerCase();
  245.                }
  246.  
  247.                return this.ttype = -3;
  248.             } else if ((var4 & 16) != 0) {
  249.                while((var3 = var1.read()) != 10 && var3 != 13 && var3 >= 0) {
  250.                }
  251.  
  252.                this.peekc = var3;
  253.                return this.nextToken();
  254.             } else if ((var4 & 8) != 0) {
  255.                this.ttype = var3;
  256.  
  257.                int var18;
  258.                for(var18 = 0; (var3 = var1.read()) >= 0 && var3 != this.ttype && var3 != 10 && var3 != 13; this.buf[var18++] = (char)var3) {
  259.                   if (var3 == 92) {
  260.                      switch (var3 = var1.read()) {
  261.                         case 48:
  262.                         case 49:
  263.                         case 50:
  264.                         case 51:
  265.                         case 52:
  266.                         case 53:
  267.                         case 54:
  268.                         case 55:
  269.                            var3 -= 48;
  270.                            int var6 = var1.read();
  271.                            if (var6 >= 48 && var6 <= 55) {
  272.                               var3 = (var3 << 3) + (var6 - 48);
  273.                               var6 = var1.read();
  274.                               if (var6 >= 48 && var6 <= 55) {
  275.                                  var3 = (var3 << 3) + (var6 - 48);
  276.                               } else {
  277.                                  this.peekc = var3;
  278.                               }
  279.                            } else {
  280.                               this.peekc = var3;
  281.                            }
  282.                            break;
  283.                         case 97:
  284.                            var3 = 7;
  285.                            break;
  286.                         case 98:
  287.                            var3 = 8;
  288.                            break;
  289.                         case 102:
  290.                            var3 = 12;
  291.                            break;
  292.                         case 110:
  293.                            var3 = 10;
  294.                            break;
  295.                         case 114:
  296.                            var3 = 13;
  297.                            break;
  298.                         case 116:
  299.                            var3 = 9;
  300.                            break;
  301.                         case 118:
  302.                            var3 = 11;
  303.                      }
  304.                   }
  305.  
  306.                   if (var18 >= this.buf.length) {
  307.                      char[] var22 = new char[this.buf.length * 2];
  308.                      System.arraycopy(this.buf, 0, var22, 0, this.buf.length);
  309.                      this.buf = var22;
  310.                   }
  311.                }
  312.  
  313.                this.peekc = 32;
  314.                this.sval = String.copyValueOf(this.buf, 0, var18);
  315.                return this.ttype;
  316.             } else if (var3 == 47 && (this.slashSlashCommentsP || this.slashStarCommentsP)) {
  317.                var3 = var1.read();
  318.                if (var3 == 42 && this.slashStarCommentsP) {
  319.                   for(int var5 = 0; (var3 = var1.read()) != 47 || var5 != 42; var5 = var3) {
  320.                      if (var3 == 10) {
  321.                         ++this.LINENO;
  322.                      }
  323.  
  324.                      if (var3 < 0) {
  325.                         return this.ttype = -1;
  326.                      }
  327.                   }
  328.  
  329.                   this.peekc = 32;
  330.                   return this.nextToken();
  331.                } else if (var3 == 47 && this.slashSlashCommentsP) {
  332.                   while((var3 = var1.read()) != 10 && var3 != 13 && var3 >= 0) {
  333.                   }
  334.  
  335.                   this.peekc = var3;
  336.                   return this.nextToken();
  337.                } else {
  338.                   this.peekc = var3;
  339.                   return this.ttype = 47;
  340.                }
  341.             } else {
  342.                this.peekc = 32;
  343.                return this.ttype = var3;
  344.             }
  345.          }
  346.       }
  347.    }
  348.  
  349.    public void pushBack() {
  350.       this.pushedBack = true;
  351.    }
  352.  
  353.    public int lineno() {
  354.       return this.LINENO;
  355.    }
  356.  
  357.    public String toString() {
  358.       String var1;
  359.       switch (this.ttype) {
  360.          case -3:
  361.             var1 = this.sval;
  362.             break;
  363.          case -2:
  364.             var1 = "n=" + this.nval;
  365.             break;
  366.          case -1:
  367.             var1 = "EOF";
  368.             break;
  369.          case 10:
  370.             var1 = "EOL";
  371.             break;
  372.          default:
  373.             char[] var2 = new char[3];
  374.             var2[0] = var2[2] = '\'';
  375.             var2[1] = (char)this.ttype;
  376.             var1 = new String(var2);
  377.       }
  378.  
  379.       return "Token[" + var1 + "], line " + this.LINENO;
  380.    }
  381. }
  382.